home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / util / misc / fifolib38_3upd.lha / fifo-383.diffs next >
Encoding:
Text File  |  1996-08-29  |  16.7 KB  |  554 lines
  1. diff -c2 unused:source/fifolib382/version.doc version.doc
  2. *** unused:source/fifolib382/version.doc    Wed Mar 27 08:47:26 1996
  3. --- version.doc    Wed Aug 28 21:38:57 1996
  4. ***************
  5. *** 4,7 ****
  6. --- 4,10 ----
  7.           The next version shall be >=2.0 only and thus become smaller.
  8.   
  9. +     38.3
  10. +         Introducing Ctrl-C/D/E/F and Ctrl-\ handling in cooked mode.
  11. + 
  12.       38.2
  13.           Processed cooked input is no more ignored in raw mode.  Cooked
  14. Common subdirectories: unused:source/fifolib382/bin and bin
  15. Common subdirectories: unused:source/fifolib382/clib and clib
  16. Only in : config.cache
  17. Only in : config.log
  18. Only in : config.status
  19. Common subdirectories: unused:source/fifolib382/fd and fd
  20. Only in : fifo-383.diffs
  21. Only in : fifo-handler
  22. Only in : fifo-handler-debug
  23. Only in : fifo-handler-debug.o
  24. diff -c2 unused:source/fifolib382/fifo-handler.c fifo-handler.c
  25. *** unused:source/fifolib382/fifo-handler.c    Mon May 13 23:07:22 1996
  26. --- fifo-handler.c    Wed Aug 28 23:40:50 1996
  27. ***************
  28. *** 42,45 ****
  29. --- 42,46 ----
  30.   void returnpacket(DosPacket *);
  31.   static inline char not_console(char *, unsigned char);
  32. + static inline short line1_length(FHan *);
  33.   void xprintf(char *, ...);
  34.   FHan *OpenHandle(char *, char *, long, long);
  35. ***************
  36. *** 71,75 ****
  37.   short        Done;    /*  could be local, but DICE2.06 uses up a register */
  38.   
  39. ! const char verstring[] = "\0$VER: fifo-handler 38.2 (8.5.96)\r\n";
  40.   
  41.   
  42. --- 72,76 ----
  43.   short        Done;    /*  could be local, but DICE2.06 uses up a register */
  44.   
  45. ! const char verstring[] = "\0$VER: fifo-handler 38.3 (28.8.96)\r\n";
  46.   
  47.   
  48. ***************
  49. *** 132,135 ****
  50. --- 133,152 ----
  51.   }
  52.   
  53. + static inline short
  54. + line1_length(FHan *han)
  55. + {
  56. +     short m = 0;
  57. +     short n = han->ff_CookIdx;
  58. +     if (n != 0) {
  59. +     --n;
  60. +     do { char c = han->ff_CookBuf[m];
  61. +          if (c == CHAR_EOF) return m;
  62. +          m++;
  63. +          if (c == '\n') return m;
  64. +     } while (--n != -1);    /*  make GCC generate dbra */
  65. +     }
  66. +     return -1;
  67. + }
  68. + 
  69.   #if !defined(__GNUC__)
  70.   __stkargs int            /*  changed from void (jch) */
  71. ***************
  72. *** 386,425 ****
  73.   
  74.           han->ff_Flags &= ~FHF_STARTCOOK; /*  restarted below */
  75. !         if (han->ff_CookBuf && han->ff_CookIdx) {
  76. !             n = strlen(han->ff_CookBuf);
  77. !             /*  read processed cooked input even in raw mode */
  78. !             if (!(han->ff_Flags & FHF_COOKED)
  79. !               || n != han->ff_CookIdx /* || han->ff_LRet superfluous */) {
  80. !             short add1 = (han->ff_Flags & FHF_COOKED || n != han->ff_CookIdx)
  81. !               ? n++    : -1;    /*  add the newline character */
  82. ! 
  83. !             D(ebug("Can read %ld chars\n", n));
  84. !             if (n > packet->dp_Arg3)
  85. !                 n = packet->dp_Arg3;
  86. !             else if (add1 >= 0)
  87. !                 han->ff_CookBuf[add1] = '\n';
  88. ! 
  89. !             memmove((void *)packet->dp_Arg2, han->ff_CookBuf, n);
  90. !             han->ff_CookIdx -= n;
  91. !             /*  overlapping memory! */
  92. !             memmove(han->ff_CookBuf, han->ff_CookBuf + n, han->ff_CookIdx + 1);
  93. !             if (han->ff_CookIdx == 0)
  94. !                 han->ff_LRet = 0;
  95. !             packet->dp_Res1 = n;
  96.   
  97.               /*
  98. !              *  if we blocked on reading the fifo to cook more
  99. !              *  data, we unblock it here.
  100.                */
  101.   
  102. !             han->ff_Flags &= ~FHF_COOKBFUL;
  103.   
  104. !             if (han->ff_Flags & FHF_COOKED &&
  105. !                 !(han->ff_Flags & FHF_RPEND)) {
  106. !                 RequestFifo(han->ff_FifoR, &han->ff_RdMsg, FREQ_RPEND);
  107. !                 han->ff_Flags |= FHF_RPEND;
  108. !             }
  109. !             break;
  110.               }
  111.           }
  112.           if (!(han->ff_Flags & FHF_COOKED)) {
  113. --- 403,455 ----
  114.   
  115.           han->ff_Flags &= ~FHF_STARTCOOK; /*  restarted below */
  116. !         if (han->ff_CookBuf
  117. !           && ((han->ff_Flags & FHF_COOKED)
  118. !               ? (0 <= han->ff_CookLen1)
  119. !               : han->ff_CookIdx)) {
  120. !             /*
  121. !              *    cooked input is available
  122. !              *    do not read too much in raw mode, a line at a time
  123. !              *    this code will fail for dp_Arg3 (# to read) == 0 in raw mode
  124. !              */
  125.   
  126. +             n = han->ff_CookLen1; /*  0 means EOF */
  127. +             D(ebug("Can read %ld chars\n", n));
  128. +             if (n > packet->dp_Arg3)
  129. +             n = packet->dp_Arg3;
  130. +             {
  131. +             long m = n;
  132.               /*
  133. !              *  CON: sends EOF in raw mode for a cooked EOF read
  134. !              *  I choose to transmit ctrl-\ because FIFO: is
  135. !              *  likely to receive pre-"typed", non-manual input
  136.                */
  137. +             if (m == 0 && !(han->ff_Flags & FHF_COOKED)) m = 1;
  138.   
  139. !             packet->dp_Res1 = m;
  140. !             memmove((void *)packet->dp_Arg2, han->ff_CookBuf, m);
  141. !             }
  142. !             if (n == 0) n = 1; /*  skip EOF marker */
  143. !             han->ff_CookIdx -= n;
  144. !             /*  overlapping memory! */
  145. !             memmove(han->ff_CookBuf, han->ff_CookBuf + n, han->ff_CookIdx);
  146.   
  147. !             if (n < han->ff_CookLen1) {
  148. !             han->ff_CookLen1 -= n;
  149. !             } else {
  150. !             han->ff_CookLen1 = line1_length(han);
  151. !             }
  152. !             /*
  153. !              *    if we blocked on reading the fifo to cook more
  154. !              *    data, we unblock it here.
  155. !              */
  156. ! 
  157. !             han->ff_Flags &= ~FHF_COOKBFUL;
  158. ! 
  159. !             if (han->ff_Flags & FHF_COOKED &&
  160. !             !(han->ff_Flags & FHF_RPEND)) {
  161. !             RequestFifo(han->ff_FifoR, &han->ff_RdMsg, FREQ_RPEND);
  162. !             han->ff_Flags |= FHF_RPEND;
  163.               }
  164. +             break;
  165.           }
  166.           if (!(han->ff_Flags & FHF_COOKED)) {
  167. ***************
  168. *** 434,439 ****
  169.               }
  170.               if (n > 0) {
  171. !             /* Hans Verkuil introduced a patch to only read upto \n,
  172. !              * however RAW: does not exhibit this behaviour.
  173.                */
  174.               if (n > packet->dp_Arg3)
  175. --- 464,469 ----
  176.               }
  177.               if (n > 0) {
  178. !             /*  Hans Verkuil introduced a patch to only read upto \n,
  179. !              *  however RAW: does not exhibit this behaviour.
  180.                */
  181.               if (n > packet->dp_Arg3)
  182. ***************
  183. *** 440,443 ****
  184. --- 470,475 ----
  185.                   n = packet->dp_Arg3;
  186.               CopyMem(ptr, (void *)packet->dp_Arg2, n);
  187. +             packet->dp_Res1 = n;
  188. + 
  189.               if (ReadFifo(han->ff_FifoR, &ptr, n) < 0)
  190.                   han->ff_Flags |= FHF_REOF;
  191. ***************
  192. *** 448,452 ****
  193.                *  unblocking from a full buffer.
  194.                */
  195. -             packet->dp_Res1 = n;
  196.               break;
  197.               }
  198. --- 480,483 ----
  199. ***************
  200. *** 487,491 ****
  201.           }
  202.   
  203. - 
  204.           /*
  205.            *  check for output stopped due to pending input line
  206. --- 518,521 ----
  207. ***************
  208. *** 495,499 ****
  209.            */
  210.   
  211. !         if ((han->ff_Flags & FHF_COOKED) && han->ff_CookIdx && han->ff_LRet == 0) {
  212.               packet->dp_Arg3 = -packet->dp_Arg3;
  213.               AddTail((MaxList *)&han->ff_WrWait, &packet->dp_Link->mn_Node);
  214. --- 525,529 ----
  215.            */
  216.   
  217. !         if ((han->ff_Flags & FHF_COOKED) && (han->ff_Flags & FHF_WISTOP)) {
  218.               packet->dp_Arg3 = -packet->dp_Arg3;
  219.               AddTail((MaxList *)&han->ff_WrWait, &packet->dp_Link->mn_Node);
  220. ***************
  221. *** 503,507 ****
  222.           }
  223.   
  224. - 
  225.           /*
  226.            *  limit size of writes to fifo to something the fifo can
  227. --- 533,536 ----
  228. ***************
  229. *** 633,637 ****
  230.           }
  231.           if (han->ff_Flags & FHF_COOKED) {
  232. !             if (han->ff_LRet || strlen(han->ff_CookBuf) != han->ff_CookIdx) {
  233.               packet->dp_Res1 = DOS_TRUE;
  234.               break;
  235. --- 662,666 ----
  236.           }
  237.           if (han->ff_Flags & FHF_COOKED) {
  238. !             if (0 <= han->ff_CookLen1) {
  239.               packet->dp_Res1 = DOS_TRUE;
  240.               break;
  241. ***************
  242. *** 676,680 ****
  243.           packet->dp_Type = ACTION_WAIT_CHAR;
  244.           if (((WaitTreq *)packet->dp_Res1)->wt_packet) {
  245. !             /*  input is available */
  246.           struct IORequest *ior = (struct IORequest *)packet->dp_Res1;
  247.   
  248. --- 705,709 ----
  249.           packet->dp_Type = ACTION_WAIT_CHAR;
  250.           if (((WaitTreq *)packet->dp_Res1)->wt_packet) {
  251. !         /*  input is available */
  252.           struct IORequest *ior = (struct IORequest *)packet->dp_Res1;
  253.   
  254. ***************
  255. *** 698,703 ****
  256.           break;
  257.       case FACTION_SCREEN_MODE:   /*    Mode                Bool:TRUE */
  258. !         /* As ACTION_SCREEN_MODE does not give a filehandle, we get it
  259. !          * indirectly through the special port. Fold packet type for safety.
  260.            */
  261.           packet->dp_Type = ACTION_SCREEN_MODE;
  262. --- 727,732 ----
  263.           break;
  264.       case FACTION_SCREEN_MODE:   /*    Mode                Bool:TRUE */
  265. !         /*  As ACTION_SCREEN_MODE does not give a filehandle, we get it
  266. !          *  indirectly through the special port. Fold packet type for safety.
  267.            */
  268.           packet->dp_Type = ACTION_SCREEN_MODE;
  269. ***************
  270. *** 708,716 ****
  271.   
  272.           if (han->ff_CookBuf == NULL) {    /*  also NULL when !FHF_READ */
  273. !             /* Normally     a shell uses cooked mode and programs might
  274. !              * also set cooked mode at exit. Thus if the
  275. !              * application did not open FIFO: in cooked mode, it
  276. !              * had good reasons to do so and we refuse any change.
  277. !              * At least this is good for GNUEmacs (uses "rwesK").
  278.                */
  279.               packet->dp_Res2 = ERROR_OBJECT_WRONG_TYPE;
  280. --- 737,745 ----
  281.   
  282.           if (han->ff_CookBuf == NULL) {    /*  also NULL when !FHF_READ */
  283. !             /*  Normally a shell uses cooked mode and programs might
  284. !              *  also set cooked mode at exit. Thus if the
  285. !              *  application did not open FIFO: in cooked mode, it
  286. !              *  had good reasons to do so and we refuse any change.
  287. !              *  At least this is good for GNUEmacs (uses "rwesK").
  288.                */
  289.               packet->dp_Res2 = ERROR_OBJECT_WRONG_TYPE;
  290. ***************
  291. *** 721,725 ****
  292.           if (DOSFALSE != packet->dp_Arg1) {    /*  RAW */
  293.               if (han->ff_Flags & FHF_COOKED) {
  294. !             han->ff_Flags &= ~(FHF_COOKED|FHF_STARTCOOK|FHF_WIHOLD|FHF_COOKECHOBLK /*|FHF_COOKBFUL --still full */);
  295.   
  296.               /*  cooked input is available, unblock readers and timers */
  297. --- 750,758 ----
  298.           if (DOSFALSE != packet->dp_Arg1) {    /*  RAW */
  299.               if (han->ff_Flags & FHF_COOKED) {
  300. !             /*
  301. !              *  this differs from CON: which unblocks neither
  302. !              *  readers nor writers until the next character is read
  303. !              */
  304. !             han->ff_Flags &= ~(FHF_COOKED|FHF_STARTCOOK|FHF_WIHOLD|FHF_WISTOP|FHF_COOKECHOBLK /*|FHF_COOKBFUL --still full */);
  305.   
  306.               /*  cooked input is available, unblock readers and timers */
  307. ***************
  308. *** 857,860 ****
  309. --- 890,894 ----
  310.       if (NULL == (han->ff_CookBuf = AllocMem(CB_SIZE, MEMF_CLEAR)))
  311.           goto fail;
  312. +     han->ff_CookLen1 = -1;
  313.       /*  lookahead for efficiency */
  314.       /*  Don't start cooked processing, application may switch to raw mode
  315. ***************
  316. *** 937,940 ****
  317. --- 971,975 ----
  318.           long i;
  319.           short rwakeup = 0;
  320. +         short eof = 0;
  321.           char *ptr;
  322.   
  323. ***************
  324. *** 948,954 ****
  325.           for (i = 0; i < n; ++i) {
  326.           switch(ptr[i]) {
  327.           case 13:
  328.           case 10:
  329. !             if (han->ff_CookIdx >= CB_SIZE - 2) {
  330.               han->ff_Flags |= FHF_COOKBFUL;
  331.               n = --i;
  332. --- 983,992 ----
  333.           for (i = 0; i < n; ++i) {
  334.           switch(ptr[i]) {
  335. +         case 28:    /*  28 is ctrl-\ is EOF */
  336. +             eof = 1;
  337. +             /*  special marker. Fall through to save some code */
  338.           case 13:
  339.           case 10:
  340. !             if (han->ff_CookIdx >= CB_SIZE - 1) {
  341.               han->ff_Flags |= FHF_COOKBFUL;
  342.               n = --i;
  343. ***************
  344. *** 962,973 ****
  345.               }
  346.               }
  347. !             /*  split buffer into \0 terminated strings */
  348. !             han->ff_CookBuf[han->ff_CookIdx++] = 0;
  349. !             han->ff_CookBuf[han->ff_CookIdx] = 0;
  350. !             han->ff_LRet = 1;
  351.               rwakeup = 1;
  352.               break;
  353.           case 8:
  354. !             if (han->ff_CookIdx && han->ff_CookBuf[han->ff_CookIdx-1] != 0) {
  355.               if (han->ff_FifoW) {
  356.                   if (WriteFifo(han->ff_FifoW, "\010 \010", 3) != 3) {
  357. --- 1000,1016 ----
  358.               }
  359.               }
  360. !             han->ff_CookBuf[han->ff_CookIdx++] = (eof ? CHAR_EOF : '\n');
  361. !             if (0 > han->ff_CookLen1) {
  362. !             /*  first line is ready, include \n but don't count EOF */
  363. !             han->ff_CookLen1 = han->ff_CookIdx - eof;
  364. !             }
  365. !             han->ff_Flags &= ~FHF_WISTOP;
  366. !             eof = 0;
  367.               rwakeup = 1;
  368.               break;
  369.           case 8:
  370. !             if (han->ff_CookIdx
  371. !               && han->ff_CookBuf[han->ff_CookIdx-1] != '\n'
  372. !               && han->ff_CookBuf[han->ff_CookIdx-1] != CHAR_EOF) {
  373.               if (han->ff_FifoW) {
  374.                   if (WriteFifo(han->ff_FifoW, "\010 \010", 3) != 3) {
  375. ***************
  376. *** 977,987 ****
  377.                   }
  378.               }
  379. !             han->ff_CookBuf[--han->ff_CookIdx] = 0;
  380. !             if (han->ff_CookIdx && han->ff_CookBuf[han->ff_CookIdx-1] == 0)
  381. !                 han->ff_LRet = 1;
  382.               }
  383.               break;
  384.           default:
  385. !             if (han->ff_CookIdx >= CB_SIZE - 2) {
  386.               han->ff_Flags |= FHF_COOKBFUL;
  387.               n = --i;
  388. --- 1020,1056 ----
  389.                   }
  390.               }
  391. !             --han->ff_CookIdx;
  392. !             if (han->ff_CookIdx==0
  393. !               || han->ff_CookBuf[han->ff_CookIdx-1] == '\n'
  394. !               || han->ff_CookBuf[han->ff_CookIdx-1] == CHAR_EOF)
  395. !                 han->ff_Flags &= ~FHF_WISTOP;
  396.               }
  397.               break;
  398. + #if 0
  399. +         case 26:    /*  test signals */
  400. +             SigHandles(han->ff_Node.ln_Name, SIGBREAKF_CTRL_C);
  401. +             break;
  402. + #endif
  403. + #if SIGBREAKB_CTRL_F - SIGBREAKB_CTRL_C == 3
  404. +         case 3: case 4: case 5: case 6:
  405. +             SigHandles(han->ff_Node.ln_Name, 1L<<(ptr[i]-3+SIGBREAKB_CTRL_C));
  406. +             break;
  407. + #else
  408. +         /*  who says the above is not portable? */
  409. +         case 3:
  410. +             SigHandles(han->ff_Node.ln_Name, SIGBREAKF_CTRL_C);
  411. +             break;
  412. +         case 4:
  413. +             SigHandles(han->ff_Node.ln_Name, SIGBREAKF_CTRL_D);
  414. +             break;
  415. +         case 5:
  416. +             SigHandles(han->ff_Node.ln_Name, SIGBREAKF_CTRL_E);
  417. +             break;
  418. +         case 6:
  419. +             SigHandles(han->ff_Node.ln_Name, SIGBREAKF_CTRL_F);
  420. +             break;
  421. + #endif
  422.           default:
  423. !             if (han->ff_CookIdx >= CB_SIZE - 1) {
  424.               han->ff_Flags |= FHF_COOKBFUL;
  425.               n = --i;
  426. ***************
  427. *** 996,1001 ****
  428.               }
  429.               han->ff_CookBuf[han->ff_CookIdx++] = ptr[i];
  430. !             han->ff_CookBuf[han->ff_CookIdx] = 0;
  431. !             han->ff_LRet = 0;
  432.               break;
  433.           }
  434. --- 1065,1069 ----
  435.               }
  436.               han->ff_CookBuf[han->ff_CookIdx++] = ptr[i];
  437. !             han->ff_Flags |= FHF_WISTOP;
  438.               break;
  439.           }
  440. ***************
  441. *** 1007,1011 ****
  442.            */
  443.   
  444. !         if ((han->ff_Flags & FHF_WIHOLD) && (han->ff_LRet || han->ff_CookIdx == 0)) {
  445.           han->ff_Flags &= ~FHF_WIHOLD;
  446.           while ((msg = (Message *)RemHead((MaxList *)&han->ff_WrWait)))
  447. --- 1075,1079 ----
  448.            */
  449.   
  450. !         if ((han->ff_Flags & FHF_WIHOLD) && !(han->ff_Flags & FHF_WISTOP)) {
  451.           han->ff_Flags &= ~FHF_WIHOLD;
  452.           while ((msg = (Message *)RemHead((MaxList *)&han->ff_WrWait)))
  453. Only in : fifo-handler.o
  454. Only in : fifo.o
  455. Only in : fifolist.c
  456. Only in : FILES
  457. Only in : FILES-bin
  458. Only in : FILES-src
  459. diff -c2 unused:source/fifolib382/handler.h handler.h
  460. *** unused:source/fifolib382/handler.h    Mon May 13 23:07:34 1996
  461. --- handler.h    Wed Aug 28 21:43:35 1996
  462. ***************
  463. *** 136,139 ****
  464. --- 136,141 ----
  465.   #define DOS_FALSE   0
  466.   
  467. + #define CHAR_EOF    '\034'
  468. + 
  469.   #define CB_SIZE     1024    /*  lines buffer */
  470.   #define FIFO_SIZE   2048
  471. ***************
  472. *** 167,171 ****
  473.       MaxNode    ff_Node;    /*    fifo node, ln_name holds fifo name */
  474.       short    ff_Flags;
  475. !     short    ff_Refs;    /*    open refs   */
  476.       SharRead    *ff_SRead;  /*    fifo handle for reading */
  477.       void    *ff_FifoW;  /*    fifo handle for writing */
  478. --- 169,173 ----
  479.       MaxNode    ff_Node;    /*    fifo node, ln_name holds fifo name */
  480.       short    ff_Flags;
  481. !     /* now longword aligned */
  482.       SharRead    *ff_SRead;  /*    fifo handle for reading */
  483.       void    *ff_FifoW;  /*    fifo handle for writing */
  484. ***************
  485. *** 178,183 ****
  486.       char    *ff_CookBuf;/*    cooked buffer handling        */
  487.       short    ff_CookIdx;
  488. !     short    ff_LRet;
  489.       MsgPort    *ff_SigPort;/*    message port instead of task to signal */
  490.   } FHan;
  491.   
  492. --- 180,186 ----
  493.       char    *ff_CookBuf;/*    cooked buffer handling        */
  494.       short    ff_CookIdx;
  495. !     short    ff_Refs;    /*    open refs   */
  496.       MsgPort    *ff_SigPort;/*    message port instead of task to signal */
  497. +     short    ff_CookLen1;/*  length of full first line of input */
  498.   } FHan;
  499.   
  500. ***************
  501. *** 184,188 ****
  502.   #define ff_FifoR    ff_SRead->sr_FifoR
  503.   
  504. ! #define FHF_COOKED    0x0001
  505.   #define FHF_RPEND    0x0002
  506.   #define FHF_WAVAIL    0x0004
  507. --- 187,191 ----
  508.   #define ff_FifoR    ff_SRead->sr_FifoR
  509.   
  510. ! #define FHF_TEE     0x0001
  511.   #define FHF_RPEND    0x0002
  512.   #define FHF_WAVAIL    0x0004
  513. ***************
  514. *** 191,195 ****
  515.   #define FHF_CLOSEEOF    0x0020
  516.   #define FHF_MASTER    0x0040
  517. ! #define FHF_TEE     0x0080
  518.   #define FHF_SHELL    0x0100
  519.   #define FHF_COOKBFUL    0x0200        /*    cooked buffer is full    */
  520. --- 194,198 ----
  521.   #define FHF_CLOSEEOF    0x0020
  522.   #define FHF_MASTER    0x0040
  523. ! #define FHF_COOKED    0x0080
  524.   #define FHF_SHELL    0x0100
  525.   #define FHF_COOKBFUL    0x0200        /*    cooked buffer is full    */
  526. ***************
  527. *** 198,202 ****
  528.   #define FHF_WIHOLD    0x1000        /*    write hold due to input */
  529.   #define FHF_COOKCRLF    0x2000        /*    need to write CRLF    */
  530. ! #define FHF_RREQUIRED    0x4000
  531.   #define FHF_STARTCOOK    0x8000        /*    start cooked processing */
  532.   
  533. --- 201,205 ----
  534.   #define FHF_WIHOLD    0x1000        /*    write hold due to input */
  535.   #define FHF_COOKCRLF    0x2000        /*    need to write CRLF    */
  536. ! #define FHF_WISTOP    0x4000        /*    delay write due to input */
  537.   #define FHF_STARTCOOK    0x8000        /*    start cooked processing */
  538.   
  539. Only in : htag.o
  540. Common subdirectories: unused:source/fifolib382/inline and inline
  541. Common subdirectories: unused:source/fifolib382/inlinef and inlinef
  542. Common subdirectories: unused:source/fifolib382/l and l
  543. Common subdirectories: unused:source/fifolib382/lib and lib
  544. Only in : lib.o
  545. Common subdirectories: unused:source/fifolib382/libraries and libraries
  546. Common subdirectories: unused:source/fifolib382/libs and libs
  547. Common subdirectories: unused:source/fifolib382/proto and proto
  548. Only in : remcli.o
  549. Only in : t.exp
  550. Only in : tag.o
  551. Only in : testfifo
  552. Only in : testfifo.o
  553. Only in : tests
  554.